/**
 * 图谱数据类型定义
 */

// 节点详细信息接口（与后端 Patent 实体字段保持一致）
export interface NodeDetail {
  applyId: string; // 申请号（对应 Patent.applyId）
  applyInstitutionZhName: string; // 申请机构名称（中文）（对应 Patent.applyInstitutionZhName）
  inventors: string[]; // 发明人列表（扩展字段）
  applyDate: string; // 申请日（对应 Patent.applyDate）
  applyPublicDate: string; // 申请公布日（对应 Patent.applyPublicDate）
  ipcClassId: string; // IPC分类号（对应 Patent.ipcClassId）
  technology: string; // 技术领域（扩展字段）
  legalStatus: string; // 法律状态（扩展字段）
  summary: string; // 摘要（源文）（对应 Patent.summary）
  summaryZh: string; // 摘要（中文）（对应 Patent.summaryZh）
  fileString?: string; // 文件（对应 Patent.fileString）
}

// 节点接口
export interface GraphNode {
  id: string; // 节点ID
  name: string; // 节点名称（专利名称）
  symbolSize: number; // 节点大小
  category: number; // 分类（0=核心专利，1=关联专利）
  value: number; // 关联度值
  detail?: NodeDetail; // 节点详细信息
  x?: number; // X坐标（可选）
  y?: number; // Y坐标（可选）
  labelMaxChars?: number; // 单行最大字符数（用于图谱文字换行）
}

// 连接关系接口
export interface GraphLink {
  source: string; // 源节点ID
  target: string; // 目标节点ID
  value: number; // 关系强度
  label?: {
    show: boolean;
  };
}

// 分类接口
export interface GraphCategory {
  name: string; // 分类名称
  itemStyle: {
    color: string; // 颜色
  };
}

// 图谱数据接口
export interface GraphData {
  nodes: GraphNode[]; // 节点列表
  links: GraphLink[]; // 连接关系列表
  categories: GraphCategory[]; // 分类列表
}

// 关联类型枚举
export enum RelationType {
  INSTITUTION = 'institution', // 申请机构关联
  INVENTOR = 'inventor', // 发明人关联
  IPC = 'ipc', // IPC分类关联
  TECHNOLOGY = 'technology', // 技术领域关联
}

// 关联类型选项
export const relationTypeOptions = [
  { label: '申请机构关联', value: RelationType.INSTITUTION },
  { label: '发明人关联', value: RelationType.INVENTOR },
  { label: 'IPC分类关联', value: RelationType.IPC },
  { label: '技术领域关联', value: RelationType.TECHNOLOGY },
];

// 默认分类配置
export const defaultCategories: GraphCategory[] = [
  { name: '核心专利', itemStyle: { color: '#9254de' } },
  { name: '关联专利', itemStyle: { color: '#1890ff' } },
];

/**
 * 后端返回的单个 Graph 对象（字段名与 Patent 实体保持一致）
 */
export interface GraphItem {
  id: string;                         // 专利ID（对应 Patent.id）
  zhName?: string;                    // 发明名称(中文)（对应 Patent.zhName）
  originName?: string;                // 发明名称(源文)（对应 Patent.originName）
  applyId?: string;                   // 申请号（对应 Patent.applyId）
  applyInstitutionZhName?: string;    // 申请机构名称（中文）（对应 Patent.applyInstitutionZhName）
  inventorZhName?: string;            // 发明人名称（中文）（对应 Patent.inventorZhName）
  inventorList?: string[];            // 发明人列表（DTO扩展字段）
  applyDate?: string;                 // 申请日（对应 Patent.applyDate）
  applyPublicDate?: string;           // 申请公布日（对应 Patent.applyPublicDate）
  ipcClassId?: string;                // IPC分类号（对应 Patent.ipcClassId）
  technology?: string;                // 技术领域（DTO扩展字段）
  legalStatus?: string;               // 法律状态（DTO扩展字段）
  summary?: string;                   // 摘要（源文）（对应 Patent.summary）
  summaryZh?: string;                 // 摘要（中文）（对应 Patent.summaryZh）
  fileString?: string;                // 文件（对应 Patent.fileString）
  relationValue?: number;             // 关联度（DTO扩展字段）
  isCore?: boolean;                   // 是否为核心专利（DTO扩展字段）
}

/**
 * 后端返回的图谱数据格式（Result<List<Graph>>）
 */
export interface GraphDataResponse {
  success: boolean;
  message: string;
  code?: number;
  result: GraphItem[];           // Graph 列表
  timestamp?: number;
}

/**
 * 节点详情查询参数
 */
export interface NodeDetailParams {
  nodeId: string;
}

/**
 * 图谱查询参数
 */
export interface GraphQueryParams {
  patent_id: string;             // 核心专利ID
  type: string;                  // 关联类型
  maxNodes?: number;             // 最大节点数（可选，默认20）
}

/**
 * 转换后端数据为前端图谱数据格式
 * @param response 后端返回的 Result<List<Graph>> 格式数据
 */
const calculateNodeVisual = (name: string, baseSize: number) => {
  const pureName = name.replace(/\s+/g, '');
  const textLength = pureName.length || name.length || 1;
  const estimatedLines = Math.max(1, Math.ceil(textLength / 6));
  const sizeByText = 40 + estimatedLines * 18;
  const symbolSize = Math.min(160, Math.max(baseSize, sizeByText));
  const labelMaxChars = Math.max(4, Math.floor(symbolSize / 12));

  return {
    symbolSize,
    labelMaxChars,
  };
};

export function transformGraphData(response: GraphDataResponse): GraphData {
  const graphList = response.result || [];
  
  if (graphList.length === 0) {
    return {
      nodes: [],
      links: [],
      categories: defaultCategories,
    };
  }

  // 分离核心专利和关联专利
  let corePatent: GraphItem | null = null;
  const relatedPatents: GraphItem[] = [];
  
  graphList.forEach(item => {
    if (item.isCore) {
      corePatent = item;
    } else {
      relatedPatents.push(item);
    }
  });

  // 如果没有明确的核心专利标记，取第一个作为核心
  if (!corePatent && graphList.length > 0) {
    corePatent = graphList[0];
    relatedPatents.push(...graphList.slice(1));
  }

  // 处理发明人字段（可能是字符串，需要转数组）
  const parseInventors = (item: GraphItem): string[] => {
    if (item.inventorList && Array.isArray(item.inventorList)) {
      return item.inventorList;
    }
    if (item.inventorZhName && typeof item.inventorZhName === 'string') {
      return item.inventorZhName.split(/[,;，；]/).map(s => s.trim()).filter(s => s);
    }
    return [];
  };

  const nodes: GraphNode[] = [];
  const links: GraphLink[] = [];

  // 添加核心专利节点
  if (corePatent) {
    const coreName = corePatent.zhName || corePatent.originName || '未命名专利';
    const coreVisual = calculateNodeVisual(coreName, 90);
    nodes.push({
      id: corePatent.id,
      name: coreName,
      symbolSize: coreVisual.symbolSize,
      category: 0,
      value: 100,
      labelMaxChars: coreVisual.labelMaxChars,
      detail: {
        applyId: corePatent.applyId || '',
        applyInstitutionZhName: corePatent.applyInstitutionZhName || '',
        inventors: parseInventors(corePatent),
        applyDate: corePatent.applyDate || '',
        applyPublicDate: corePatent.applyPublicDate || '',
        ipcClassId: corePatent.ipcClassId || '',
        technology: corePatent.technology || '',
        legalStatus: corePatent.legalStatus || '未知',
        summary: corePatent.summary || '',
        summaryZh: corePatent.summaryZh || '',
        fileString: corePatent.fileString,
      },
    });
  }

  // 添加关联专利节点和连接关系
  relatedPatents.forEach((patent) => {
    const nodeId = patent.id;
    const relationValue = patent.relationValue || 0.5;
    const nodeName = patent.zhName || patent.originName || '未命名专利';
    const baseSize = 50 + relationValue * 25;
    const nodeVisual = calculateNodeVisual(nodeName, baseSize);
    
    nodes.push({
      id: nodeId,
      name: nodeName,
      symbolSize: nodeVisual.symbolSize,
      category: 1,
      value: relationValue * 100,
      labelMaxChars: nodeVisual.labelMaxChars,
      detail: {
        applyId: patent.applyId || '',
        applyInstitutionZhName: patent.applyInstitutionZhName || '',
        inventors: parseInventors(patent),
        applyDate: patent.applyDate || '',
        applyPublicDate: patent.applyPublicDate || '',
        ipcClassId: patent.ipcClassId || '',
        technology: patent.technology || '',
        legalStatus: patent.legalStatus || '未知',
        summary: patent.summary || '',
        summaryZh: patent.summaryZh || '',
        fileString: patent.fileString,
      },
    });

    // 添加从核心专利到关联专利的连接
    if (corePatent) {
      links.push({
        source: corePatent.id,
        target: nodeId,
        value: relationValue * 10,
        label: { show: false },
      });
    }
  });

  return {
    nodes,
    links,
    categories: defaultCategories,
  };
}
